

// Lambda 表达式：

// 1. 为泛型 Collection<T> 拓展 fold 函数接口
// 2. combine 为 lambda 表达式
fun<T, R> Collection<T>.fold(initial : R, combine : (R, T) -> R) : R {
    var accumulator : R = initial

    for (element : T in this) {
        accumulator = combine(accumulator, element)
    }

    return accumulator
}

//fun main() {
//    val numbers = listOf<Int>(1, 2, 3)
//
//    val res = numbers.fold<Int, Int>(1, { acc : Int, cur : Int ->
//            acc + cur
//    })
//    println(res)
//
//    val res2 = numbers.fold(0, { acc : Int, cur : Int -> acc + cur })
//    println(res2)
//
////    val res2 = numbers.fold(0) {acc, cur -> acc + cur}
//
//    return
//}

//fun main() {
//
//    val numbers = listOf(1, 2, 3, 4, 5)
//
//    numbers.fold(0) { acc : Int, cur : Int ->
//        print("acc = $acc, cur = $cur, ")
//        val result = acc + cur
//        println("result = $result")
//
//        result
//    }
//
//    return
//}


// 函数类型：

//fun main() {
////    var control by remember { mutableStateOf(false) } // Composable 语法
//
//    // 匿名函数
//    val stoi : (String) -> Int = fun(s : String) : Int { return s.toIntOrNull() ?: 0}
//    println(stoi("aa"))
//    println(stoi("1"))
//
//
//}

//fun isOdd(x : Int) = x % 2 == 1
//
//fun isEven(x : Int) : Boolean {
//    return x % 2 == 0
//}
//
//fun main() {
//
//    val numbers = listOf(1, 2, 3, 4, 5, 6)
//    val odds = numbers.filter(::isOdd) // ::isOdd 是一个顶层函数；把函数引用传给 filter
//    val evens = numbers.filter(::isEven)
//
//    print("奇数：")
//    for (odd in odds) {
//        print("$odd ")
//    }
//
//    print("\n偶数：")
//    for (even in evens) {
//        print("$even ")
//    }
//
//    return
//}

//class Logger {
//    fun log(msg : String) = println("LOG: $msg")
//}
//
//fun main() {
//    val logger = Logger()
//    // 绑定可调用引用
//    val callback : (String) -> Unit = logger::log // 绑定 log
//
//    callback("hello") // 相当于 logger.log("hello")
//
//    return
//}

//class IntTransformer : (Int) -> Int {
//    // invoke 是让对象可以像函数一样调用的特殊方法名
//    // invoke 类似于 C++ 中的 operator()
//    // IntTransformer(5) == IntTransformer().invoke(5)
//    override operator fun invoke(x : Int) : Int {
//        // (Int) -> Int 是 Function1<Int, Int>
//        // override
//        return x * 2 + 3
//    }
//}
//
//fun main() {
//    val intTransformer = IntTransformer()
////    println(intTransformer(3))
////
////    val numbers = listOf(1, 3, 4, 6, 7)
////
////    val transformed = numbers.map(intTransformer)
////    println(transformed)
//
//    val f : (Int) -> Int = intTransformer
//    println(f(5))
//
//    val f2 : (Int) -> Int = IntTransformer()
//    println(f2(3))
//
//    println(IntTransformer().invoke(3))
//
//    f.invoke(10)
//}

fun main() {
    val stringPlus : (String, String) -> String = String::plus
    val intPlus : Int.(Int) -> Int = Int::plus

    println(stringPlus.invoke("<-", "->"))
    println(stringPlus("hello, ", "world"))

    println(intPlus(1, 2))
    println(intPlus.invoke(2, 3))
    println(1.intPlus(3))

}